package com.module.ble.utils

import com.common.base.utils.AppUtils
import com.common.base.utils.AppUtils.getString
import com.common.base.utils.JsonUtils
import com.module.ble.R
import com.module.ble.data.bean.CusChartData
import com.module.ble.data.bean.CusUnifyData
import com.module.ble.db.table.UserAcLevel
import com.module.ble.db.table.UserCalorie
import com.module.ble.db.table.UserSleepInfo
import com.module.ble.db.table.UserStand
import com.module.ble.db.table.UserStepsRelatedRecord
import com.module.ble.db.table.UserStress
import java.util.Calendar

/**
 *
 * 作者：sosou
 *
 * 版本：1.0
 *
 * 创建日期：14/8/2025
 *
 * 描述：健康数据转换相关工具类
 *
 * 修订历史：
 *
 */
/**
 * 根据sleepQuality和时间间隔对睡眠数据进行分组
 * @param originalList 原始睡眠数据列表（已按时间排序）
 * @return 分组后的CusChartData列表
 */
//fun groupSleepDataByQualityAndTime(originalList: List<UserSleepInfo>): List<CusChartData> {
//    if (originalList.isEmpty()) return emptyList()
//
//    val result = mutableListOf<CusChartData>()
//    val thirtyMinutesInMillis = 30 * 60 * 1000L // 30分钟的毫秒数
//
//    var currentGroup = mutableListOf<UserSleepInfo>()
//    var currentSleepQuality: Int? = null
//
//    for (i in originalList.indices) {
//        val currentItem = originalList[i]
//
//        // 检查是否需要开始新的分组
//        val shouldStartNewGroup = when {
//            currentGroup.isEmpty() -> false // 第一个元素，不需要开始新组
//            currentItem.sleepQuality != currentSleepQuality -> true // sleepQuality不同
//            i > 0 && (currentItem.createdTime - originalList[i-1].createdTime) >= thirtyMinutesInMillis -> true // 时间间隔>=30分钟
//            else -> false
//        }
//
//        if (shouldStartNewGroup && currentGroup.isNotEmpty()) {
//            // 处理当前组，生成CusChartData
//            val groupStartTime = currentGroup.first().createdTime
//            val groupEndTime = if (currentGroup.size > 1) {
//                currentGroup.last().createdTime
//            } else {
//                // 单条数据的组，使用当前数据的时间作为结束时间
//                currentItem.createdTime
//            }
//            val groupDuration = ((groupEndTime - groupStartTime) / (1000 * 60)).toInt() // 转换为分钟
//            val groupQuality = currentSleepQuality ?: -2
//
//            result.add(CusChartData(
//                createdTime = groupStartTime,
//                timeLong = groupDuration,
//                status = groupQuality,
//                mOrder = when(groupQuality) {
//                    -1 -> 3// 未佩戴 -> 离床
//                    0 -> 3// 清醒(离床) -> 清醒
//                    1 -> 2// 快速眼动 -> 快速眼动
//                    2 -> 1// 浅睡 -> 浅睡
//                    3 -> 0// 深睡 -> 深睡
//                    else -> 3
//                }
//            ))
//
//            // 检查是否需要插入未知类型数据（时间间隔）
//            if (i > 0) {
//                val previousItem = originalList[i-1]
//                val timeGap = currentItem.createdTime - previousItem.createdTime
//
//                if (timeGap >= thirtyMinutesInMillis) {
//                    // 插入未知类型数据
//                    val gapDuration = ((timeGap) / (1000 * 60)).toInt()
//                    result.add(CusChartData(
//                        createdTime = previousItem.createdTime,
//                        timeLong = gapDuration,
//                        status = -999, // 未知类型
//                        mOrder = 3
//                    ))
//                }
//            }
//
//            // 开始新的分组
//            currentGroup.clear()
//        }
//
//        // 将当前元素添加到当前组
//        currentGroup.add(currentItem)
//        currentSleepQuality = currentItem.sleepQuality
//    }
//
//    // 处理最后一组
//    if (currentGroup.isNotEmpty()) {
//        val groupStartTime = currentGroup.first().createdTime
//        val groupEndTime = if (currentGroup.size > 1) {
//            currentGroup.last().createdTime
//        } else {
//            // 最后一组如果只有一条数据，时长设为0或者根据业务需求设定
//            groupStartTime // 这里可以根据实际需求调整
//        }
//        val groupDuration = ((groupEndTime - groupStartTime) / (1000 * 60)).toInt()
//        val groupQuality = currentSleepQuality ?: -2
//
//        result.add(CusChartData(
//            createdTime = groupStartTime,
//            timeLong = groupDuration,
//            status = groupQuality,
//            mOrder = when(groupQuality) {
//                -1 -> 3// 未佩戴 -> 离床
//                0 -> 3// 清醒(离床) -> 清醒
//                1 -> 2// 快速眼动 -> 快速眼动
//                2 -> 1// 浅睡 -> 浅睡
//                3 -> 0// 深睡 -> 深睡
//                else -> 3
//            }
//        ))
//    }
//
////    val listItStr = JsonUtils.toJson(result)
//
//    return result
//}
fun groupSleepDataByQualityAndTime(originalList: List<UserSleepInfo>): List<CusChartData> {
    if (originalList.isEmpty()) return emptyList()

    val result = mutableListOf<CusChartData>()
    val thirtyMinutesInMillis = 30 * 60 * 1000L // 30分钟的毫秒数

    var i = 0
    while (i < originalList.size) {
        val currentItem = originalList[i]
        var groupEndIndex = i

        // 查找当前组的结束位置
        while (groupEndIndex + 1 < originalList.size) {
            val nextItem = originalList[groupEndIndex + 1]

            // 如果下一条数据的sleepQuality不同，则结束当前组
            if (nextItem.sleepQuality != currentItem.sleepQuality) {
                break
            }

            // 如果时间间隔>=30分钟，也结束当前组
            if ((nextItem.createdTime - originalList[groupEndIndex].createdTime) >= thirtyMinutesInMillis) {
                break
            }

            groupEndIndex++
        }

        // 当前组的结束时间：如果因为时间间隔>=30分钟而结束，使用最后一个有效数据的时间
        // 如果因为sleepQuality不同而结束，使用下一条数据的时间
        val groupEndTime = if (groupEndIndex + 1 < originalList.size) {
            val nextItem = originalList[groupEndIndex + 1]
            if ((nextItem.createdTime - originalList[groupEndIndex].createdTime) >= thirtyMinutesInMillis) {
                // 时间间隔>=30分钟，使用当前组最后一条数据的时间
                originalList[groupEndIndex].createdTime
            } else {
                // sleepQuality不同，使用下一条数据的时间
                nextItem.createdTime
            }
        } else {
            // 最后一组，使用最后一条数据的时间
            originalList[groupEndIndex].createdTime
        }

        val groupDuration = groupEndTime - currentItem.createdTime

        // 添加当前组的CusChartData
        result.add(CusChartData(
            createdTime = currentItem.createdTime,
            endTime = groupEndTime,
            timeLong = (groupDuration / (1000 * 60)).toInt(), // 转换为分钟
            status = currentItem.sleepQuality,
            mOrder = when(currentItem.sleepQuality) {
                4 -> 3 // 卧床
                5 -> 3 // 未佩戴 -> 离床
                0 -> 3  // 清醒 -> 清醒
                1 -> 2  // 快速眼动 -> 快速眼动
                2 -> 1  // 浅睡 -> 浅睡
                3 -> 0  // 深睡 -> 深睡
                else -> 3
            }
        ))

        // 检查是否需要插入未知类型数据（时间间隔>=30分钟）
        if (groupEndIndex + 1 < originalList.size) {
            val nextItem = originalList[groupEndIndex + 1]
            val timeGap = nextItem.createdTime - originalList[groupEndIndex].createdTime

            if (timeGap >= thirtyMinutesInMillis) {
                // 插入未知类型数据
                result.add(CusChartData(
                    createdTime = originalList[groupEndIndex].createdTime,
                    endTime = nextItem.createdTime,
                    timeLong = (timeGap / (1000 * 60)).toInt(), // 转换为分钟
                    status = -999, // 未知类型
                    mOrder = 3
                ))
            }
        }

        // 移动到下一组的开始位置
        i = groupEndIndex + 1
    }

//    val listItStr = JsonUtils.toJson(result)
    return result
}

fun groupUserStandByQualityAndType(originalList: List<UserStand>): List<CusChartData> {
    if (originalList.isEmpty()) return mutableListOf()

    val result = mutableListOf<CusChartData>()
    val thirtyMinutesInMillis = 30 * 60 * 1000L // 30分钟的毫秒数

    var i = 0
    while (i < originalList.size) {
        val currentItem = originalList[i]
        var groupEndIndex = i

        // 查找当前组的结束位置
        while (groupEndIndex + 1 < originalList.size) {
            val nextItem = originalList[groupEndIndex + 1]

            // 如果下一条数据的standType不同，则结束当前组
            if (nextItem.standType != currentItem.standType) {
                break
            }

            // 如果时间间隔>=30分钟，也结束当前组
            if ((nextItem.createdTime - originalList[groupEndIndex].createdTime) >= thirtyMinutesInMillis) {
                break
            }

            groupEndIndex++
        }

        // 当前组的结束时间：如果因为时间间隔>=30分钟而结束，使用最后一个有效数据的时间
        // 如果因为standType不同而结束，使用下一条数据的时间
        val groupEndTime = if (groupEndIndex + 1 < originalList.size) {
            val nextItem = originalList[groupEndIndex + 1]
            if ((nextItem.createdTime - originalList[groupEndIndex].createdTime) >= thirtyMinutesInMillis) {
                // 时间间隔>=30分钟，使用当前组最后一条数据的时间
                originalList[groupEndIndex].createdTime
            } else {
                // sleepQuality不同，使用下一条数据的时间
                nextItem.createdTime
            }
        } else {
            // 最后一组，使用最后一条数据的时间
            originalList[groupEndIndex].createdTime
        }

        val groupDuration = groupEndTime - currentItem.createdTime

        // 添加当前组的CusChartData
        result.add(CusChartData(
            createdTime = currentItem.createdTime,
            endTime = groupEndTime,
            timeLong = (groupDuration / (1000 * 60)).toInt(), // 转换为分钟
            status = currentItem.standType.toInt(),
            mOrder = currentItem.standType.toInt()
        ))

        // 移动到下一组的开始位置
        i = groupEndIndex + 1
    }

    return result.filter { it.status > 0 }
}

fun groupAcLevelDataByValueAndTime(originalList: List<UserAcLevel>): List<CusChartData> {
    if (originalList.isEmpty()) return emptyList()

    val result = mutableListOf<CusChartData>()
    val thirtyMinutesInMillis = 30 * 60 * 1000L // 30分钟的毫秒数

    var i = 0
    while (i < originalList.size) {
        val currentItem = originalList[i]
        val currentItemInterval = when {
            currentItem.acLevel >= 80f -> 80 // 80-100: 红色
            currentItem.acLevel >= 60f ->60f // 60-80: 橙色
            currentItem.acLevel >= 30f -> 30f // 30-60: 黄色
            else -> 0 // 0-30: 浅蓝色
        }
        var groupEndIndex = i

        // 查找当前组的结束位置
        while (groupEndIndex + 1 < originalList.size) {
            val nextItem = originalList[groupEndIndex + 1]

            val nextItemInterval = when {
                nextItem.acLevel >= 80f -> 80 // 80-100: 红色
                nextItem.acLevel >= 60f ->60f // 60-80: 橙色
                nextItem.acLevel >= 30f -> 30f // 30-60: 黄色
                else -> 0 // 0-30: 浅蓝色
            }

            // 如果下一条数据的区间值不同，则结束当前组
            if (nextItemInterval != currentItemInterval) {
                break
            }

            // 如果时间间隔>=30分钟，也结束当前组
            if ((nextItem.createdTime - originalList[groupEndIndex].createdTime) >= thirtyMinutesInMillis) {
                break
            }

            groupEndIndex++
        }

        // 当前组的结束时间：如果因为时间间隔>=30分钟而结束，使用最后一个有效数据的时间
        // 如果因为区间值不同而结束，使用下一条数据的时间
        val groupEndTime = if (groupEndIndex + 1 < originalList.size) {
            val nextItem = originalList[groupEndIndex + 1]
            if ((nextItem.createdTime - originalList[groupEndIndex].createdTime) >= thirtyMinutesInMillis) {
                // 时间间隔>=30分钟，使用当前组最后一条数据的时间
                originalList[groupEndIndex].createdTime
            } else {
                // 区间值不同，使用下一条数据的时间
                nextItem.createdTime
            }
        } else {
            // 最后一组，使用最后一条数据的时间
            originalList[groupEndIndex].createdTime
        }

        val groupDuration = groupEndTime - currentItem.createdTime

        // 添加当前组的CusChartData
        result.add(CusChartData(
            createdTime = currentItem.createdTime,
            endTime = groupEndTime,
            timeLong = (groupDuration / (1000 * 60)).toInt(), // 转换为分钟
            status = when {
                currentItem.acLevel >= 80f -> 80 // 80-100: 红色
                currentItem.acLevel >= 60f ->60 // 60-80: 橙色
                currentItem.acLevel >= 30f -> 30 // 30-60: 黄色
                else -> 0 // 0-30: 浅蓝色
            },
        ))

        // 检查是否需要插入未知类型数据（时间间隔>=30分钟）
        if (groupEndIndex + 1 < originalList.size) {
            val nextItem = originalList[groupEndIndex + 1]
            val timeGap = nextItem.createdTime - originalList[groupEndIndex].createdTime

            if (timeGap >= thirtyMinutesInMillis) {
                // 插入未知类型数据
                result.add(CusChartData(
                    createdTime = originalList[groupEndIndex].createdTime,
                    endTime = nextItem.createdTime,
                    timeLong = (timeGap / (1000 * 60)).toInt(), // 转换为分钟
                    status = -999, // 未知类型
                    mOrder = 3
                ))
            }
        }

        // 移动到下一组的开始位置
        i = groupEndIndex + 1
    }

//    val listItStr = JsonUtils.toJson(result)
    return result
}


/**
 * 根据sleepQuality和时间间隔对睡眠数据进行分组
 * @param originalList 原始睡眠数据列表（已按时间排序）
 * @return 分组后的CusChartData列表
 */
fun groupStressDataByStressAndTime(originalList: List<UserStress>): List<CusChartData> {
    if (originalList.isEmpty()) return emptyList()

    val result = mutableListOf<CusChartData>()
    val thirtyMinutesInMillis = 30 * 60 * 1000L // 30分钟的毫秒数

    var i = 0
    while (i < originalList.size) {
        val currentItem = originalList[i]

        // 根据stress值确定压力分类
        val currentStressCategory = when(currentItem.stress.toInt()) {
            in 0..30 -> 0    // 放松
            in 31..60 -> 1   // 正常
            in 61..80 -> 2   // 中等
            in 81..100 -> 3  // 偏高
            else -> -1       // 无效数据
        }

        var groupEndIndex = i

        // 查找当前组的结束位置
        while (groupEndIndex + 1 < originalList.size) {
            val nextItem = originalList[groupEndIndex + 1]

            // 根据下一条数据的stress值确定压力分类
            val nextStressCategory = when(nextItem.stress.toInt()) {
                in 0..30 -> 0    // 放松
                in 31..60 -> 1   // 正常
                in 61..80 -> 2   // 中等
                in 81..100 -> 3  // 偏高
                else -> -1       // 无效数据
            }

            // 如果下一条数据的压力分类不同，则结束当前组
            if (nextStressCategory != currentStressCategory) {
                break
            }

            // 如果时间间隔>=30分钟，也结束当前组
            if ((nextItem.createdTime - originalList[groupEndIndex].createdTime) >= thirtyMinutesInMillis) {
                break
            }

            groupEndIndex++
        }

        // 当前组的结束时间：如果因为时间间隔>=30分钟而结束，使用最后一个有效数据的时间
        // 如果因为压力分类不同而结束，使用下一条数据的时间
        val groupEndTime = if (groupEndIndex + 1 < originalList.size) {
            val nextItem = originalList[groupEndIndex + 1]
            if ((nextItem.createdTime - originalList[groupEndIndex].createdTime) >= thirtyMinutesInMillis) {
                // 时间间隔>=30分钟，使用当前组最后一条数据的时间
                originalList[groupEndIndex].createdTime
            } else {
                // 压力分类不同，使用下一条数据的时间
                nextItem.createdTime
            }
        } else {
            // 最后一组，使用最后一条数据的时间
            originalList[groupEndIndex].createdTime
        }

        val groupDuration = groupEndTime - currentItem.createdTime

        // 添加当前组的CusChartData
        result.add(CusChartData(
            createdTime = currentItem.createdTime,
            endTime = groupEndTime,
            timeLong = (groupDuration / 1000).toInt(), // 转换为秒
            status = currentStressCategory,
            mOrder = when(currentStressCategory) {
                0 -> 0  // 放松
                1 -> 1  // 正常
                2 -> 2  // 中等
                3 -> 3  // 偏高
                else -> -1 // 无效数据
            }
        ))

        // 检查是否需要插入未知类型数据（时间间隔>=30分钟）
        if (groupEndIndex + 1 < originalList.size) {
            val nextItem = originalList[groupEndIndex + 1]
            val timeGap = nextItem.createdTime - originalList[groupEndIndex].createdTime

            if (timeGap >= thirtyMinutesInMillis) {
                // 插入未知类型数据
                result.add(CusChartData(
                    createdTime = originalList[groupEndIndex].createdTime,
                    endTime = nextItem.createdTime,
                    timeLong = (timeGap / 1000).toInt(), // 转换为秒
                    status = -999, // 未知类型
                    mOrder = 3
                ))
            }
        }

        // 移动到下一组的开始位置
        i = groupEndIndex + 1
    }

    val listItStr = JsonUtils.toJson(result)
    return result.filter { it.status>0 }
}

fun common48DataConvertToAverage(curTime:Long, originalList: List<CusUnifyData>): List<CusChartData>{

    if (originalList.isEmpty()) return emptyList()
    if (curTime <= 0) return emptyList()

    // 创建48个时间区间块的CusChartData数组
    val result = mutableListOf<CusChartData>()

    // 获取curTime当天的0点时间戳
    val calendar = Calendar.getInstance()
    calendar.timeInMillis = curTime
    calendar.set(Calendar.HOUR_OF_DAY, 0)
    calendar.set(Calendar.MINUTE, 0)
    calendar.set(Calendar.SECOND, 0)
    calendar.set(Calendar.MILLISECOND, 0)
    val startOfDay = calendar.timeInMillis

    for (index in 0 until 48) {
        val timeOffset = index * 30 * 60 * 1000L // 每30分钟的时间偏移
        val intervalStartTime = startOfDay + timeOffset
        val intervalEndTime = startOfDay + timeOffset + (30 * 60 * 1000L) // 加30分钟作为结束时间

        result.add(
            CusChartData(
                createdTime = intervalStartTime,
                endTime = intervalEndTime,
                mValue = -1f,
                minValue = 0f,
                dayNum = 0
            )
        )
    }

    val stressListDataInitStr = JsonUtils.toJson(result)

    // 将originalListIt中的压力数据按时间区间分组并计算平均值
    for (intervalIndex in result.indices) {
        val interval = result[intervalIndex]
        val intervalStart = interval.createdTime
        val intervalEnd = interval.endTime

        // 找到属于当前时间区间的所有压力数据
        val stressValuesInInterval = originalList.filter { stressData ->
            stressData.createdTime in intervalStart until intervalEnd
        }

        // 如果该时间区间内有数据，计算平均值
        if (stressValuesInInterval.isNotEmpty()) {
            val averageStress = stressValuesInInterval.map { it.value.toInt() }.average().toFloat()
            result[intervalIndex] = result[intervalIndex].copy(mValue = averageStress)
        }
    }
    return result
}

fun common48DataConvert(doSum: Boolean=false,curTime:Long, originalList: List<CusUnifyData>): List<CusChartData>{

    if (originalList.isEmpty()) return emptyList()
    if (curTime <= 0) return emptyList()

    // 创建48个时间区间块的CusChartData数组
    val result = mutableListOf<CusChartData>()

    // 获取curTime当天的0点时间戳
    val calendar = Calendar.getInstance()
    calendar.timeInMillis = curTime
    calendar.set(Calendar.HOUR_OF_DAY, 0)
    calendar.set(Calendar.MINUTE, 0)
    calendar.set(Calendar.SECOND, 0)
    calendar.set(Calendar.MILLISECOND, 0)
    val startOfDay = calendar.timeInMillis

    for (index in 0 until 48) {
        val timeOffset = index * 30 * 60 * 1000L // 每30分钟的时间偏移
        val intervalStartTime = startOfDay + timeOffset
        val intervalEndTime = startOfDay + timeOffset + (30 * 60 * 1000L) // 加30分钟作为结束时间

        result.add(
            CusChartData(
                createdTime = intervalStartTime,
                endTime = intervalEndTime,
                mValue = 0f,
                minValue = 0f,
                dayNum = 0
            )
        )
    }

//    val stressListDataInitStr = JsonUtils.toJson(result)

    // 将originalListIt中的压力数据按时间区间分组并计算平均值
    for (intervalIndex in result.indices) {
        val interval = result[intervalIndex]
        val intervalStart = interval.createdTime
        val intervalEnd = interval.endTime

        // 找到属于当前时间区间的所有压力数据
        val stressValuesInInterval = originalList.filter { stressData ->
            stressData.createdTime in intervalStart until intervalEnd
        }

        // 如果该时间区间内有数据，计算总和
        if (stressValuesInInterval.isNotEmpty()) {
            val averageStress = if (doSum) stressValuesInInterval.sumOf { it.value.toInt() }.toFloat() else stressValuesInInterval.map { it.value.toInt() }.average().toFloat()
            result[intervalIndex] = result[intervalIndex].copy(mValue = averageStress)
            result[intervalIndex] = result[intervalIndex].copy(exStr = averageStress.toInt().toString())
        }
    }
    return result
}

fun common24DataConvert(doSum: Boolean=false,curTime:Long, originalList: List<CusUnifyData>): List<CusChartData>{

    if (originalList.isEmpty()) return emptyList()
    if (curTime <= 0) return emptyList()

    // 创建24个时间区间块的CusChartData数组
    val result = mutableListOf<CusChartData>()

    // 获取curTime当天的0点时间戳
    val calendar = Calendar.getInstance()
    calendar.timeInMillis = curTime
    calendar.set(Calendar.HOUR_OF_DAY, 0)
    calendar.set(Calendar.MINUTE, 0)
    calendar.set(Calendar.SECOND, 0)
    calendar.set(Calendar.MILLISECOND, 0)
    val startOfDay = calendar.timeInMillis

    for (index in 0 until 24) {
        val timeOffset = index * 60 * 60 * 1000L // 每60分钟（1小时）的时间偏移
        val intervalStartTime = startOfDay + timeOffset
        val intervalEndTime = startOfDay + timeOffset + (60 * 60 * 1000L) // 加60分钟作为结束时间

        result.add(
            CusChartData(
                createdTime = intervalStartTime,
                endTime = intervalEndTime,
                mValue = 0f,
                minValue = 0f,
                dayNum = 0
            )
        )
    }

//    val stressListDataInitStr = JsonUtils.toJson(result)

    // 将originalListIt中的压力数据按时间区间分组并计算平均值
    for (intervalIndex in result.indices) {
        val interval = result[intervalIndex]
        val intervalStart = interval.createdTime
        val intervalEnd = interval.endTime

        // 找到属于当前时间区间的所有压力数据
        val stressValuesInInterval = originalList.filter { stressData ->
            stressData.createdTime in intervalStart until intervalEnd
        }

        // 如果该时间区间内有数据，计算总和
        if (stressValuesInInterval.isNotEmpty()) {
            val averageStress = if (doSum) stressValuesInInterval.sumOf { it.value.toInt() }.toFloat() else stressValuesInInterval.map { it.value.toInt() }.average().toFloat()
            result[intervalIndex] = result[intervalIndex].copy(mValue = averageStress)
            result[intervalIndex] = result[intervalIndex].copy(exStr = averageStress.toInt().toString())
        }
    }
    return result
}

fun common48DataConvertByStepsRelatedRecord(mType:Int=0, doSum: Boolean=false,curTime:Long, originalList: List<UserStepsRelatedRecord>): List<CusChartData>{

    if (originalList.isEmpty()) return emptyList()
    if (curTime <= 0) return emptyList()

    // 创建48个时间区间块的CusChartData数组
    val result = mutableListOf<CusChartData>()

    // 获取curTime当天的0点时间戳
    val calendar = Calendar.getInstance()
    calendar.timeInMillis = curTime
    calendar.set(Calendar.HOUR_OF_DAY, 0)
    calendar.set(Calendar.MINUTE, 0)
    calendar.set(Calendar.SECOND, 0)
    calendar.set(Calendar.MILLISECOND, 0)
    val startOfDay = calendar.timeInMillis

    for (index in 0 until 48) {
        val timeOffset = index * 30 * 60 * 1000L // 每30分钟的时间偏移
        val intervalStartTime = startOfDay + timeOffset
        val intervalEndTime = startOfDay + timeOffset + (30 * 60 * 1000L) // 加30分钟作为结束时间

        result.add(
            CusChartData(
                createdTime = intervalStartTime,
                endTime = intervalEndTime,
                mValue = 0f,
                minValue = 0f,
                dayNum = 0
            )
        )
    }

    val stressListDataInitStr = JsonUtils.toJson(result)

    // 将originalListIt中的压力数据按时间区间分组并计算平均值
    for (intervalIndex in result.indices) {
        val interval = result[intervalIndex]
        val intervalStart = interval.createdTime
        val intervalEnd = interval.endTime

        // 找到属于当前时间区间的所有压力数据
        val stressValuesInInterval = originalList.filter { stressData ->
            stressData.createdTime in intervalStart until intervalEnd
        }

        // 如果该时间区间内有数据，计算总和
        if (stressValuesInInterval.isNotEmpty()) {
            val averageStress = when(mType){
                2->if (doSum) stressValuesInInterval.sumOf { it.distance.toInt() }.toFloat() else stressValuesInInterval.map { it.distance.toInt() }.average().toFloat()
                else -> if (doSum) stressValuesInInterval.sumOf { it.step.toInt() }.toFloat() else stressValuesInInterval.map { it.step.toInt() }.average().toFloat()
            }
            result[intervalIndex] = result[intervalIndex].copy(mValue = averageStress)
            result[intervalIndex] = result[intervalIndex].copy(exStr = averageStress.toInt().toString())
        }
    }
    return result
}


fun common48DataConvertByCalorieRelatedRecord(doSum: Boolean=false,curTime:Long, originalList: List<UserCalorie>): List<CusChartData>{

    if (originalList.isEmpty()) return emptyList()
    if (curTime <= 0) return emptyList()

    // 创建48个时间区间块的CusChartData数组
    val result = mutableListOf<CusChartData>()

    // 获取curTime当天的0点时间戳
    val calendar = Calendar.getInstance()
    calendar.timeInMillis = curTime
    calendar.set(Calendar.HOUR_OF_DAY, 0)
    calendar.set(Calendar.MINUTE, 0)
    calendar.set(Calendar.SECOND, 0)
    calendar.set(Calendar.MILLISECOND, 0)
    val startOfDay = calendar.timeInMillis

    for (index in 0 until 48) {
        val timeOffset = index * 30 * 60 * 1000L // 每30分钟的时间偏移
        val intervalStartTime = startOfDay + timeOffset
        val intervalEndTime = startOfDay + timeOffset + (30 * 60 * 1000L) // 加30分钟作为结束时间

        result.add(
            CusChartData(
                createdTime = intervalStartTime,
                endTime = intervalEndTime,
                mValue = 0f,
                minValue = 0f,
                dayNum = 0
            )
        )
    }

    val stressListDataInitStr = JsonUtils.toJson(result)

    // 将originalListIt中的压力数据按时间区间分组并计算平均值
    for (intervalIndex in result.indices) {
        val interval = result[intervalIndex]
        val intervalStart = interval.createdTime
        val intervalEnd = interval.endTime

        // 找到属于当前时间区间的所有压力数据
        val stressValuesInInterval = originalList.filter { stressData ->
            stressData.createdTime in intervalStart until intervalEnd
        }

        // 如果该时间区间内有数据，计算总和
        if (stressValuesInInterval.isNotEmpty()) {
            val averageStress =  if (doSum) stressValuesInInterval.sumOf { it.calorie.toInt() }.toFloat() else stressValuesInInterval.map { it.calorie.toInt() }.average().toFloat()
            result[intervalIndex] = result[intervalIndex].copy(mValue = averageStress)
            result[intervalIndex] = result[intervalIndex].copy(exStr = averageStress.toInt().toString())
        }
    }
    return result
}

fun common48DataConvertByStressRecord(doSum: Boolean=false,curTime:Long, originalList: List<UserStress>): List<CusChartData>{

    if (originalList.isEmpty()) return emptyList()
    if (curTime <= 0) return emptyList()

    // 创建48个时间区间块的CusChartData数组
    val result = mutableListOf<CusChartData>()

    // 获取curTime当天的0点时间戳
    val calendar = Calendar.getInstance()
    calendar.timeInMillis = curTime
    calendar.set(Calendar.HOUR_OF_DAY, 0)
    calendar.set(Calendar.MINUTE, 0)
    calendar.set(Calendar.SECOND, 0)
    calendar.set(Calendar.MILLISECOND, 0)
    val startOfDay = calendar.timeInMillis

    for (index in 0 until 48) {
        val timeOffset = index * 30 * 60 * 1000L // 每30分钟的时间偏移
        val intervalStartTime = startOfDay + timeOffset
        val intervalEndTime = startOfDay + timeOffset + (30 * 60 * 1000L) // 加30分钟作为结束时间

        result.add(
            CusChartData(
                createdTime = intervalStartTime,
                endTime = intervalEndTime,
                mValue = -1f,
                minValue = 0f,
                dayNum = 0
            )
        )
    }

//    val stressListDataInitStr = JsonUtils.toJson(result)

    // 将originalListIt中的压力数据按时间区间分组并计算平均值
    for (intervalIndex in result.indices) {
        val interval = result[intervalIndex]
        val intervalStart = interval.createdTime
        val intervalEnd = interval.endTime

        // 找到属于当前时间区间的所有压力数据
        val stressValuesInInterval = originalList.filter { stressData ->
            stressData.createdTime in intervalStart until intervalEnd
        }

        // 如果该时间区间内有数据，计算总和
        if (stressValuesInInterval.isNotEmpty()) {
            val averageStress = if (doSum) stressValuesInInterval.sumOf { it.stress.toInt() }.toFloat() else stressValuesInInterval.map { it.stress.toInt() }.average().toFloat()
            result[intervalIndex] = result[intervalIndex].copy(mValue = averageStress)
            result[intervalIndex] = result[intervalIndex].copy(exStr = averageStress.toInt().toString())
        }
    }
    return result
}

fun common48DataConvertByAcLevelRelatedRecord(curTime:Long, originalList: List<UserAcLevel>, minValue:Int = 0): List<CusChartData>{

    if (originalList.isEmpty()) return emptyList()
    if (curTime <= 0) return emptyList()

    // 获取curTime当天的0点时间戳
    val calendar = Calendar.getInstance()
    calendar.timeInMillis = curTime
    calendar.set(Calendar.HOUR_OF_DAY, 0)
    calendar.set(Calendar.MINUTE, 0)
    calendar.set(Calendar.SECOND, 0)
    calendar.set(Calendar.MILLISECOND, 0)
    val startOfDay = calendar.timeInMillis


    // 每天48个时间区间数据 - 使用List<Pair>格式
    val theDays48Pairs = mutableListOf<Pair<String, MutableList<UserAcLevel>>>()

    // 创建48个时间区间（每30分钟一个）
    for (index in 0 until 48) {
        val intervalStartTime = startOfDay + (index * 30 * 60 * 1000L) // 每30分钟的时间偏移
        val intervalEndTime = startOfDay + ((index + 1) * 30 * 60 * 1000L) // 下一个30分钟区间的开始时间

        // 生成时间区间字符串（如：00:00~00:30, 00:30~01:00）
        val startHour = index / 2
        val startMinute = (index % 2) * 30
        val endHour = (index + 1) / 2
        val endMinute = ((index + 1) % 2) * 30

        val startTimeString = String.format("%02d:%02d", startHour, startMinute)
        val endTimeString = String.format("%02d:%02d", endHour % 24, endMinute)
        val timeRangeString = "$startTimeString~$endTimeString"

        // 筛选该时间区间内的UserAcLevel数据
        val intervalData = originalList.filter { userAcLevel ->
            userAcLevel.createdTime in intervalStartTime until intervalEndTime
        }.toMutableList()

        // 添加到theDays48Pairs
        theDays48Pairs.add(Pair(timeRangeString, intervalData))
    }

    val theDays48PairsStr = JsonUtils.toJson(theDays48Pairs)

    // 每个区间取下一个区间第一条数据插入到当前区间末尾
    for (i in 0 until theDays48Pairs.size - 1) {
        val currentPair = theDays48Pairs[i]
        val nextPair = theDays48Pairs[i + 1]

        // 如果下一个区间有数据，取第一条数据插入到当前区间末尾
        if (nextPair.second.isNotEmpty()) {
            val firstDataFromNextInterval = nextPair.second.first()
            currentPair.second.add(firstDataFromNextInterval)
        }
    }

    val theDays48PairsStr2 = JsonUtils.toJson(theDays48Pairs)

    // 创建48个时间区间块的CusChartData数组
    val result = mutableListOf<CusChartData>()
    for (index in 0 until 48) {
        val timeOffset = index * 30 * 60 * 1000L // 每30分钟的时间偏移
        val intervalStartTime = startOfDay + timeOffset
        val intervalEndTime = startOfDay + timeOffset + (30 * 60 * 1000L) // 加30分钟作为结束时间

        result.add(
            CusChartData(
                createdTime = intervalStartTime,
                endTime = intervalEndTime,
                mValue = 0f,
                minValue = 0f,
                dayNum = 0
            )
        )
    }

    val stressListDataInitStr = JsonUtils.toJson(result)

    for (index in 0 until minOf(result.size, theDays48Pairs.size)) {
        val totalTime = groupAcLevelDataByValueAndTime(originalList = theDays48Pairs[index].second).filter{it.status >=minValue}.toMutableList().sumOf { it.timeLong }
        result[index].mValue = totalTime.toFloat()
    }

    return result
}

fun getStressStateStrByValue(mValue:Int):String{
    return when(mValue){
        in 0..30 -> AppUtils.getString(R.string.common_pressure_relax_hint)
        in 31..60 -> AppUtils.getString(R.string.common_pressure_normal_hint)
        in 61..80 -> AppUtils.getString(R.string.common_pressure_medium_hint)
        in 81..100 -> AppUtils.getString(R.string.common_pressure_high_hint)
        else -> AppUtils.getString(R.string.common_pressure_relax_hint)
    }
}